"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var fs = require("fs");
var path = require("path");
// Read mint.json
var mintJson = JSON.parse(fs.readFileSync('./mint.json', 'utf8'));
// Function to get all markdown files recursively
function getAllMarkdownFiles(dir) {
    var results = [];
    var files = fs.readdirSync(dir);
    for (var _i = 0, files_1 = files; _i < files_1.length; _i++) {
        var file = files_1[_i];
        var filePath = path.join(dir, file);
        var stat = fs.statSync(filePath);
        if (stat.isDirectory()) {
            results = results.concat(getAllMarkdownFiles(filePath));
        }
        else if (file.endsWith('.md')) {
            results.push(filePath.replace(/\\/g, '/'));
        }
    }
    return results;
}
// Function to get all paths from mint.json navigation
function getAllMintPaths(navigation) {
    var paths = [];
    function extractPaths(item) {
        if (typeof item === 'string') {
            paths.push(item);
        }
        else if (item.pages) {
            item.pages.forEach(function (page) { return extractPaths(page); });
        }
    }
    navigation.forEach(function (section) {
        if (section.pages) {
            section.pages.forEach(function (page) { return extractPaths(page); });
        }
    });
    return paths;
}
// Get all markdown files
var docsDir = './docs';
var markdownFiles = getAllMarkdownFiles(docsDir)
    .map(function (file) { return file.replace('docs/', '').replace('.md', ''); });
// Get all paths from mint.json
var mintPaths = getAllMintPaths(mintJson.navigation);
// Check for files not in mint.json
console.log('Files not in mint.json:');
markdownFiles.forEach(function (file) {
    if (!mintPaths.includes(file)) {
        console.log(file);
    }
});
// Check for paths in mint.json that don't exist as files
console.log('\nPaths in mint.json that don\'t exist as files:');
mintPaths.forEach(function (path) {
    // Skip app/ paths as they're API routes
    if (!path.startsWith('app/') && !markdownFiles.includes(path)) {
        console.log(path);
    }
});


require('dotenv').config();
const fs = require('fs');

// Terms to preserve exactly
const PRESERVE_TERMS = [
    'A/B Testing',
    'API',
    'LLM',
    'Machine Learning',
    'Redis',
    'PostgreSQL',
    'Elasticsearch',
    'OAuth',
    'JWT',
    'Circuit Breaker'
];

// Common words to remove unless they're part of a preserved term
const WORDS_TO_REMOVE = [
    'System',
    'Module',
    'Component',
    'Service',
    'Implementation',
    'Management',
    'Features',
    'Functionality',
    'Overview',
    'Documentation',
    'Details',
    'Information',
    'Configuration',
    'Setup'
];

// Title mappings for specific cases
const TITLE_MAPPINGS = {
    // Core sections
    'Authentication And Security': 'Auth & Security',
    'Session And User Management': 'User Sessions',
    'Core Operations': 'Core Services',
    'Search And Documents': 'Search & Docs',
    'Data Storage': 'Data Storage',
    'Adaptation And Learning': 'ML & Adaptation',
    'Analytics And Reporting': 'Analytics & Reports',
    'Monitoring And Observability': 'Monitoring',
    'System Utilities': 'Core Utils',
    
    // Feature sections
    'Large Language Models': 'LLM Integration',
    'Core Analytics Service': 'Analytics Engine',
    'Redis Session Cache': 'Redis Cache',
    'Circuit Breaker Implementation': 'Circuit Breaker',
    'Elasticsearch Operations': 'Elasticsearch',
    'Document Processing': 'Doc Processing',
    'Search Operations': 'Search Engine',
    'Monitoring System': 'System Monitor',
    'Metrics Collection': 'Metrics',
    'Event Processing': 'Event Handler',
    
    // API & Services
    'API Operations': 'API Routes',
    'API Documentation': 'API Reference',
    'Service Configuration': 'Services Config',
    'Service Registry': 'Service Registry',
    
    // Database & Storage
    'Database Operations': 'Database',
    'Redis Operations': 'Redis',
    'Storage Configuration': 'Storage Config',
    
    // Auth & Security
    'Authentication Setup': 'Auth Setup',
    'Security Configuration': 'Security Config',
    'User Management': 'User Admin',
    'Session Handling': 'Sessions',
    
    // Learning & Adaptation
    'Learning Pipeline': 'ML Pipeline',
    'Adaptation Engine': 'Adaptation',
    'Feedback Processing': 'Feedback',
    'Model Training': 'Training',
    
    // Monitoring & Analytics
    'Analytics Engine': 'Analytics',
    'Monitoring Setup': 'Monitor Setup',
    'Metrics Dashboard': 'Dashboards',
    'Alert Configuration': 'Alerts',
    
    // Core Features
    'Core Features': 'Features',
    'Core Components': 'Components',
    'Core Services': 'Services',
    
    // Utils & Tools
    'Utility Functions': 'Utils',
    'Development Tools': 'Dev Tools',
    'Testing Framework': 'Testing',
    
    // Types & Interfaces
    'Type Definitions': 'Types',
    'Interface Definitions': 'Interfaces',
    'Model Schemas': 'Schemas'
};

function cleanTitle(title) {
    // If it's a preserved term, return as is
    if (PRESERVE_TERMS.includes(title)) {
        return title;
    }

    // Check for direct mapping
    if (TITLE_MAPPINGS[title]) {
        return TITLE_MAPPINGS[title];
    }

    // Split by common delimiters
    let parts = title.split(/\s*[-–—]\s*/);
    
    // Take the most meaningful part (usually the first)
    let mainPart = parts[0];

    // Remove common words unless they're part of a preserved term
    WORDS_TO_REMOVE.forEach(word => {
        const regex = new RegExp(`\\s*\\b${word}\\b\\s*`, 'gi');
        mainPart = mainPart.replace(regex, ' ');
    });

    // Clean up extra spaces and trim
    mainPart = mainPart.replace(/\s+/g, ' ').trim();

    // If we've removed too much, use the original title
    if (mainPart.length < 3) {
        mainPart = parts[0];
    }

    return mainPart;
}

async function processNavigation(navigation) {
    const processedNavigation = [];

    for (const item of navigation) {
        if (typeof item === 'string') {
            // Don't modify page URLs
            processedNavigation.push(item);
            continue;
        }

        const processedItem = { ...item };
        if (processedItem.group) {
            processedItem.group = cleanTitle(processedItem.group);
        }

        if (Array.isArray(processedItem.pages)) {
            processedItem.pages = await processNavigation(processedItem.pages);
        }

        processedNavigation.push(processedItem);
    }

    return processedNavigation;
}

async function main() {
    try {
        console.log('Reading mint.json...');
        const mintJson = JSON.parse(fs.readFileSync('mint.json', 'utf8'));

        if (!mintJson.navigation || !Array.isArray(mintJson.navigation)) {
            throw new Error('Invalid navigation structure');
        }

        console.log('Processing titles...');
        const processedNavigation = await processNavigation(mintJson.navigation);

        // Update mint.json with processed navigation
        mintJson.navigation = processedNavigation;
        fs.writeFileSync('mint.json', JSON.stringify(mintJson, null, 2));
        console.log('Successfully updated navigation with concise titles');

        // Print out the transformations
        console.log('\nTitle Transformations:');
        for (const [original, concise] of Object.entries(TITLE_MAPPINGS)) {
            console.log(`"${original}" → "${concise}"`);
        }
    } catch (error) {
        console.error('Error processing navigation:', error);
        process.exit(1);
    }
}

main(); 

Get Experiments

Sophra

Introduction

Quickstart

README

Robust JWT-based authentication and authorization middleware for admin API routes in the Sophra system

Admin Authentication Middleware

A robust permission management system for Sophra's admin API endpoints

Admin Permissions Module

Returns Prometheus-formatted metrics for all API endpoints. Tracks request counts, durations, sizes, errors, and active requests across normalized endpoint patterns. Metrics are exposed with appropriate labels for method, endpoint, and status.

Metrics exposed:
- sophra_api_requests_total: Counter of total API requests by method, endpoint, and status
- sophra_api_request_duration_seconds: Histogram of request durations by method and endpoint
- sophra_api_response_size_bytes: Histogram of response sizes by method and endpoint
- sophra_api_errors_total: Counter of API errors by method, endpoint, and error type
- sophra_api_active_requests: Gauge of currently active requests by method

Get API Metrics

Get Metrics

Request Server Key

# Health Check Endpoint

The Health Check endpoint offers a clear overview of Sophra's core service health through a single API call. It provides detailed operational status and performance metrics for all critical system components. The Health Check endpoint offers a comprehensive overview of the health of Sophra's core services through a unified API call. This endpoint is designed to provide users with clear insights into the operational status and performance metrics of all critical system components.

When accessed, it returns detailed information that allows developers and system administrators to quickly assess the overall functionality and reliability of the system. Key performance indicators, such as response times, error rates, and resource utilization, are included in the response, enabling users to identify potential issues before they escalate.

Additionally, the Health Check endpoint can serve as an essential tool for monitoring system health over time, helping teams maintain optimal performance and ensure high availability of services. By leveraging this endpoint, organizations can enhance their operational efficiency and provide a better experience for their users.

**Request**

``` http
GET /health

 ```

**Response**

``` json
{
  "success": true,
  "data": {
    "timestamp": "2024-03-20T10:30:00.000Z",
    "services": {
      "elasticsearch": {
        "operational": true,
        "latency": 123,
        "metrics": {
          "cluster": {
            "status": "green",
            "nodes": 3,
            "activePrimaryShards": 5
          },
          "indices": {
            "total": 10,
            "healthy": 10
          },
          "performance": {
            "queryLatency": 45,
            "cpuUsage": 0.75
          }
        }
      },
      "postgres": {
        "operational": true,
        "latency": 85,
        "metrics": {
          "connections": {
            "active": 12,
            "idle": 4
          },
          "performance": {
            "queryLatency": 30,
            "cacheHitRatio": 0.95
          }
        }
      },
      "redis": {
        "operational": true,
        "latency": 15,
        "metrics": {
          "memory": {
            "used": "1.2gb",
            "fragmentationRatio": 1.3
          },
          "performance": {
            "opsPerSecond": 1500
          }
        }
      }
    },
    "overall": true
  },
  "meta": {
    "took": 223
  }
}

 ```

Health Check

Get Session

Create Session

Get Session Analytics

Create Index

Get Indices

Create Document

Vectorize Document

Get Document

Update Document

Verify Document

Hybrid Search

Create A/B Test

Assign to A/B Test

Log Search Analytics

Get Analytics Report

Get Feedback Requests

Record Search Feedback

Check Health

Create Experiment

Activate Experiment

Submit Results

Deactivate Experiment

Get Rules

Create Rules

Generated from cURL: curl -X POST http://localhost:3000/api/adapt/suggest \
  -H "Content-Type: application/json" \
  -d '{
    "queryHash": "hash_of_search_query",
    "patterns": {
      "positivePatterns": ["good_result_pattern"],
      "negativePatterns": ["bad_result_pattern"],
      "neutralPatterns": ["neutral_pattern"]
    },
    "confidence": 0.85
  }'

Suggest New Rule

Apply Rules

Create Model

Get Model by ID

Sync Model State

Search Patterns

Get Recent Feedback

Submit Feedback

Get Feedback Pattern Analysis

Get Learning Metrics

Get Learning Events

Get Signals

Create Signal

Record Signal Event

Observe Signals

Get cortexdocuments

Put cortexdocuments

Get cortexsessions analytics

GitHub

API Reference

Get Started

Support

A TypeScript client for interacting with OpenAI's fine-tuning API, optimized for Sophra's machine learning pipeline.

OpenAI Client for Fine-Tuning and Model Management

A robust configuration management system for the Sophra data synchronization and management layer

Configuration Management System

A robust, type-safe configuration management system for the Sophra data synchronization platform

Sophra Configuration Management

Comprehensive type definitions and schemas for Sophra's configuration system

Configuration Type Definitions for Sophra

Core component for managing ML model configurations and versioning in Sophra's adaptive learning system

Model Registry and Configuration Management

RESTful API for managing machine learning model configurations and versions in the Sophra system

Model Configuration and Management API

Advanced API endpoint for synchronizing machine learning model states and metrics in the Sophra system

Model Synchronization API

A robust metadata schema validation and storage system for Sophra's data management layer

Metadata Management System

A robust versioning system for managing data entry lifecycles in the Sophra ecosystem

Version Management System for Sophra

Comprehensive TypeScript interfaces for Sophra's sophisticated search capabilities

Advanced Search Types for Sophra

Comprehensive TypeScript interface defining core services for the Sophra data synchronization and management system

Sophra Services Interface

Core type definitions for Sophra's adaptive rule system, enabling dynamic data processing and system behavior modification.

Adaptation Types for Sophra's Intelligent Data Processing

Core event definitions and processing interfaces for the Sophra data synchronization system

Event Types and Processing for Sophra

A sophisticated event-driven learning framework for Sophra's adaptive data processing and optimization pipeline.

Learning Event System for Adaptive Data Processing

Comprehensive type definitions and interfaces for Sophra's adaptive learning system models

Model Types and Configurations for Sophra's Machine Learning Pipeline

Advanced signal handling and processing infrastructure for the Sophra data intelligence platform

Signal Processing and Analysis System

High-performance API endpoint for batch processing and indexing of documents in Sophra's Elasticsearch cluster

Bulk Document Ingestion API

High-performance API route for document ingestion and processing in the Sophra System

Cortex Document API Route

Next.js API route for verifying document existence in Elasticsearch indices

Document Verification API Route

Advanced API for analyzing and storing search patterns in Sophra's adaptive learning system

Search Patterns Learning API

Advanced search endpoint leveraging Elasticsearch for text, vector, and hybrid queries with faceting and event tracking

Cortex Search API Route

Next.js API route for assigning variants in A/B tests with comprehensive error handling and metrics tracking

AB Test Assignment API Route

Next.js API route for creating A/B tests in the Sophra System's Cortex module

A/B Test Creation API Route

Advanced A/B testing implementation with real-time metrics and statistical analysis

A/B Testing Service for Sophra

RESTful endpoint for activating A/B testing experiments in the Sophra System

A/B Testing Experiment Activation API

RESTful API for managing A/B testing experiments in the Sophra System

A/B Testing Experiment Management API

High-performance API for recording and retrieving A/B test metrics in the Sophra System

A/B Testing Results API

A Next.js API route for applying adaptive rules in the Sophra system

Adaptation Rule Application API

Next.js API route for managing adaptive learning rules in the Sophra system

Adaptation Rules API Route

Next.js API route for processing and storing adaptation suggestions in the Sophra system

Adaptation Suggestion API Route

Adaptive search optimization through continuous pattern analysis and strategy validation

Real-Time Learning Engine

Core engine for adaptive learning and optimization in the Sophra system

Nous Engine Service

Core type definitions and interfaces for the Sophra Nous Engine, powering adaptive learning and optimization strategies.

Nous Engine Types and Interfaces

Advanced feedback processing and analytics endpoint for the Sophra System

Cortex Feedback API Route

Advanced feedback handling and analytics for Sophra's adaptive learning system

Feedback Processing API Route

Foundational service layer for Sophra's microservices ecosystem

Core Service Architecture

A robust service for managing data consistency across Elasticsearch, PostgreSQL, and Redis in the Sophra system.

Data Synchronization Service

A robust utility for creating secure Elasticsearch configurations in the Sophra system

Elasticsearch Configuration Generator

A robust module for setting up and managing Elasticsearch indices in the Sophra system

Elasticsearch Index Initialization

Advanced query construction for Sophra's Elasticsearch integration

Elasticsearch Query Builder

Core type definitions and query interfaces for Elasticsearch integration in Sophra

Elasticsearch Types and Query Interfaces

A robust health check endpoint for the Sophra Cortex Engine, providing detailed operational metrics and system status.

Cortex Engine Health API

A Next.js middleware for validating admin tokens in API requests

Admin Middleware for API Key Management

A robust API key management system for Sophra's authentication and authorization infrastructure

API Key Management System

A Next.js middleware component for API key validation, rate limiting, and usage tracking

API Middleware for Authentication and Rate Limiting

A robust error handling middleware for the Sophra System's Cortex module

Cortex Error Handler Middleware

A robust PostgreSQL integration service for Sophra's data management layer

PostgreSQL Data Service

A high-performance, Redis-backed session and conversation management service for the Sophra System

SessionCacheService - Redis-Powered Conversation Memory

Core type definitions and configurations for Sophra's Redis caching layer

Redis Service Types and Configurations

Advanced error management and formatting for the Sophra System

Error Handling Utilities

A singleton class managing service lifecycle and dependencies for the Sophra system's Nous Observe module.

Service Manager for Nous Observe Module

A robust Next.js response generator for standardized API outputs in the Sophra system

Signal Response Utility

Advanced request validation and schema management for the Sophra data synchronization system

Validation Utilities for Sophra

A robust health check endpoint for the Sophra system, integrating OpenAI connectivity validation

Health Check API Route

A robust health check endpoint for monitoring Sophra system components

A comprehensive metrics collection and reporting system for the Sophra platform

Sophra Metrics Service

Advanced monitoring configuration for Sophra's observability pipeline

Metrics Configuration Module

Next.js API route for observing and analyzing signal data in the Sophra system

Signal Observation API Route

Advanced signal processing and management endpoint for the Sophra System

Signal Processing API Route

RESTful API endpoint for managing and querying Sophra's signal processing system

Nous Signals API Route

A robust analytics engine for tracking and analyzing search events in the Sophra system

Analytics Service for Sophra

Core type definitions for Sophra's analytics engine, providing structured data models for metrics, trends, insights, and reporting.

Analytics Types for Sophra's Cortex System

A Next.js API route for generating and retrieving analytics reports within the Sophra system

Analytics Report Generation API

Next.js API route for logging and retrieving search analytics in the Sophra system

Search Analytics API Route

Next.js API route for retrieving and managing learning events in the Sophra system

Learning Events API Route

Advanced metrics retrieval endpoint for Sophra's adaptive learning system

Learning Metrics API Route

Next.js API route for retrieving Prometheus-formatted metrics from the Sophra system

Cortex > Metrics

Administration

Cortex > System Health

Cortex > Session Management

Cortex > Index Management

Cortex > Document Operations

Cortex > Search Operations

Cortex > A/B Testing

Cortex > Analytics

Cortex > Feedback

Nous > Health

Nous > A/B Testing

Nous > Adaptation

Nous > Learning > Models

Nous > Learning > Search Patterns

Nous > Learning > Feedback

Nous > Learning > Metrics and Events

Nous > Signals

API Reference

Get Experiments

Response